from Tkinter import *
import pickle
import tkSimpleDialog as tks
import tkFileDialog as tkf
import tkMessageBox as tkm
import random
from batiment import *
from Etoile import *
from Planete import *
from unite import *
from univers import *
import threedlib
from CadreActions import *

class Vue(object):
    def __init__(self, parent):
        self.parent=parent
        self.camera = threedlib.Camera()
        self.camera.centrerOeil(800,1200)        
        self.root=Tk()
        self.root.title("Apes of Empires")
        self.posSourisX=0
        self.posSourisY=0
        self.couleurs = {}
        
        #######################
        ##  Ecran de depart  ##
        #######################
        self.root.config(bg="black")
        self.framePrincipal=Frame(self.root, bg="black")

        ##Section Header/Photo
        self.frameHeader=Frame(self.framePrincipal,bg="black")
        self.imageHeader=PhotoImage(file="img/ApesOfEmpires.gif")
        self.labelHeader=Label(self.frameHeader, image=self.imageHeader, bg="black") 

        ##Section Configurations Joueur
        #Le titre + Le cadre
        self.titreJoueur=Label(self.framePrincipal, text="Configurations Joueur",fg="CornflowerBlue",font=("Helvetica", 10, "bold italic"), bg="black")
        self.frameJoueur=LabelFrame(self.framePrincipal, labelwidget=self.titreJoueur,padx=10,pady=10,width=500, bg="black",relief=GROOVE, bd=8)
        #les labels et les champs
        self.labelVotreNom=Label(self.frameJoueur, text="Votre nom SVP", fg="gray", bg="black")
        self.entryVotreNom=Entry(self.frameJoueur) 
        #valeur par defaut du champs nom
        self.entryVotreNom.insert(0,"Joueur"+str(random.randrange( 0, 10000 )))
        
        ##Section Configuration Multijoueur
        #Le titre + Le cadre
        self.titreMultijoueur=Label(self.framePrincipal, text="Configurations Multijoueur",fg="CornflowerBlue",font=("Helvetica", 10, "bold italic"), bg="black")
        self.frameMultijoueur=LabelFrame(self.framePrincipal, labelwidget=self.titreMultijoueur,padx=10,pady=10, bg="black",width=500,relief=GROOVE, bd=8)       
        #les boutons
        self.boutonJoindre=Button(self.frameMultijoueur, text="Joindre une partie", command=self.parent.joindrePartie,bg="grey15",fg="CornflowerBlue",activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=20)
        self.labelEspacement=Label(self.frameMultijoueur, fg="black", bg="black")
        self.boutonCustom=Button(self.frameMultijoueur, text="Creer une partie", command=self.creerCustom,bg="grey15",fg="CornflowerBlue",activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=20)      
        #les labels et les champs
        self.labeEtoiles=Label(self.frameMultijoueur, text="Nombre d'etoiles :", fg="gray", bg="black")
        self.labelLargeur=Label(self.frameMultijoueur, text="Largeur univers :", fg="gray", bg="black")
        self.labelHauteur=Label(self.frameMultijoueur, text="Hauteur univers :", fg="gray", bg="black")
        self.labelProfondeur=Label(self.frameMultijoueur, text="Profondeur univers :", fg="gray", bg="black")
        self.labelAI=Label(self.frameMultijoueur, text="Nombre d'AI :", fg="gray", bg="black")
        self.nbAI=Entry(self.frameMultijoueur,width=7)
        self.nbEtoiles=Entry(self.frameMultijoueur,width=7)
        self.largeur=Entry(self.frameMultijoueur,width=7)
        self.hauteur=Entry(self.frameMultijoueur,width=7)
        self.profondeur=Entry(self.frameMultijoueur,width=7)    
        
        #Valeurs par defaut champs multijoueur 
        self.nbEtoiles.insert(0,20)
        self.largeur.insert(0,100)
        self.hauteur.insert(0,100)
        self.profondeur.insert(0,100)
        self.nbAI.insert(0,5)
  
        ##Ecran de jeu
        self.width, self.height = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
        #self.root.overrideredirect(1)
        #self.root.geometry("%dx%d+0+0" % (w, h))
        #POUR METTRE EN FULL SCREE ENLEVER LES LIGNE CI HAUT DE COMMENTAIRE
        self.frameJeu=Frame(self.root, bg= 'black')
        self.root.geometry('+0+0')
        self.canvasJoueur = Canvas(self.frameJeu, height=(self.height/3)*2, width=(self.width/3)/2, bg ='black',bd=5, relief=RIDGE)
        self.canvasJoueur.grid(row=0 , column=0)
        self.canvasJeu = Canvas(self.frameJeu, height=(self.height/3)*2, width=(self.width/3)*2, bg="black")
        self.canvasJeu.grid(row=0 , column=1)
        self.canvasOption = Canvas(self.frameJeu, height=(self.height/3)*2, width=(self.width/3)/2, bg='black',bd=5, relief=RIDGE)
        self.canvasOption.grid(row=0, column=2)
        self.listeSelect=Listbox(self.frameJeu)
        self.corner=PhotoImage(file = "img/corner.gif")
        self.frameStat= Frame(self.root,height=self.height/3,width=500,bg="black")
        self.canvasStat=Canvas(self.frameStat, height=self.height/3, width=500, bg="blue")
        self.canvasCoin=Canvas(self.frameStat,height=200,width=250,bg='black')
        self.canvasCoin2=Canvas(self.frameStat,height=200,width=250,bg='black')
        self.canvasCoin.create_image(0,0,image=self.corner,anchor=NW)
        self.canvasCoin2.create_image(0,0,image=self.corner,anchor=NW)
        self.canvasCoin.grid(row=0,column=0)
        self.creerChat()
        self.canvasCoin2.grid(row=0,column=3)
        self.menuEtoile = Button(self.canvasOption, text="Etoiles", command = self.listEtoile,activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=10)
        self.menuUnite = Button(self.canvasOption, text="Unites", command = self.listUnite,activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=10)
        self.menuPlanete = Button(self.canvasOption, text="Planetes", command = self.listPlanete,activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=10)
        self.menuStructure = Button(self.canvasOption, text="Structures", command = self.listStructure,activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=10)
        self.boutonTech=Button(self.canvasOption, text="Arbre de Technologie", command=self.technologie,bg="grey15",fg="CornflowerBlue",activebackground="grey10",activeforeground="CornflowerBlue",relief=RIDGE,bd=4,width=20)
        self.menuUnite.place(x=10,y=200)
        self.menuEtoile.place(x=10,y=250)
        self.cadreBoutton=CadreActions(self.canvasStat)
        self.canvasJeu.bind("<ButtonPress-1>", self.clicGauche)
        self.canvasJeu.bind("<ButtonPress-3>", self.deplacer)
        self.canvasJeu.bind("<ButtonPress-2>", self.attaquer)
        self.canvasJeu.bind("<B1-Motion>", self.deplacerCamera)
        self.canvasJeu.bind("<B2-Motion>", self.rotationCamera)
        self.root.bind("<Return>", self.enterChat)
        self.selectionne=""
        self.cible=0
        self.bouttonGuidePresse = False
        self.bouttonAttaquePresse = False
        self.bouttonAvancePresse = False
        self.bouttonShieldDisruptPresse = False
        self.bouttonReparerPresse = False
        self.listSelectionner = False
        self.listEtoileSelectionner = False
        self.chatOuvert = False
        self.afficherEcranDepart()
        
    def afficherEcranDepart(self):
        ##Positioner et afficher les elements de depart
        self.labelHeader.pack()
        self.frameHeader.pack()
        self.labelVotreNom.pack()
        self.entryVotreNom.pack()
        self.frameJoueur.pack(fill=BOTH)
        self.boutonJoindre.grid(row=0,column=0, sticky=W)
        self.labelEspacement.grid(row=1,column=0, sticky=W)
        self.boutonCustom.grid(row=2, column=0, sticky=W)
        self.labeEtoiles.grid(row=4,column=0, sticky=W)
        self.labelLargeur.grid(row=5,column=0, sticky=W)
        self.labelHauteur.grid(row=6,column=0, sticky=W)
        self.labelProfondeur.grid(row=7,column=0, sticky=W)       
        self.labelAI.grid(row=8, column=0, sticky=W)
        self.nbEtoiles.grid(row=4, column=1)
        self.largeur.grid(row=5, column=1)
        self.hauteur.grid(row=6, column=1)
        self.profondeur.grid(row=7, column=1)     
        self.nbAI.grid(row=8, column=1)
        self.frameMultijoueur.pack(fill=BOTH)
        self.framePrincipal.pack()                

    def creerCustom(self):
        nbEtoiles=int(self.nbEtoiles.get())
        largeur=int(self.largeur.get())
        hauteur=int(self.hauteur.get())
        profondeur=int(self.profondeur.get())
        nbAI = int(self.nbAI.get())
        self.camera.milieu = threedlib.Point(largeur/2, hauteur/2, profondeur/2)
        self.parent.creerDefaut(nbEtoiles,largeur,hauteur,profondeur, nbAI)
                
    def partieEnCours(self):
        self.framePrincipal.forget()
        self.selectionne=""
        self.etoileSelectionnee=""
        self.planeteSelectionnee=""
        self.structureSelectionnee=""
        self.listeEtoilesEcran = []
        self.frameJeu.pack()
        self.frameStat.pack()
    
        self.boutonTech.place(x=15,y=500)
        #self.stat()
        self.uniteBool=False
        self.etoileBool=False
        self.afficher()
        self.statJoueur()
        self.miniMap()

    
    def clicDansUnite(self, event):
        compteur=0

        for i in self.listeUnitesEcran:
            if event.x > i.x and event.y > i.y:
                if event.x < i.x + ((600-i.z)/50)+2:
                    if event.y < i.y + ((600-i.z)/50)+2:
                        return compteur
            compteur += 1
        return -1
    
    def clicDansEtoile(self, event):
        compteur = 0
        
        for i in self.listeEtoilesEcran:
            if event.x > i.x and event.y > i.y:
                if event.x < i.x + ((600-i.z)/50)+2:
                    if event.y < i.y + ((600-i.z)/50)+2:
                        return compteur
            compteur += 1
        return -1
    
    def selection(self, event):
        self.structureSelectionnee = ""
        self.planeteSelectionnee = ""
        if not self.listSelectionner:
            self.selectionne = ""
        if not self.listEtoileSelectionner:
            self.etoileSelectionnee = ""
        tab = self.parent.getTabUnites()
        unite = self.clicDansUnite(event)
        if unite <> -1 or self.listSelectionner:
            if not self.listSelectionner:
                if (tab[unite].statut == 'vivant'):
                    self.selectionne = unite
            self.canvasStat.destroy()
            self.canvasStat=Canvas(self.frameStat, height=200, width=500, bg="blue")
            self.imageUnite=""
            if self.selectionne<>"":
                pourcentHealth=float(self.parent.getTabUnites()[self.selectionne].hp)/float(CONSTANTESUNITES.unites[self.parent.getTabUnites()[self.selectionne].type]['hp'])
                pourcentShields=float(self.parent.getTabUnites()[self.selectionne].shields)/float(CONSTANTESUNITES.unites[self.parent.getTabUnites()[self.selectionne].type]['shields'])
                self.canvasStat.create_text(50,10, text="Health",fill="white")
                self.canvasStat.create_rectangle(90,5,150,15,fill="blue",outline="white")
                self.canvasStat.create_rectangle(90,5,90+(60*pourcentHealth),15,fill="white")
                self.uniteHP = self.canvasStat.create_text(180,10, text=self.parent.getTabUnites()[self.selectionne].hp, fill="white")
                self.canvasStat.create_text(50,30, text="Defense",fill="white")
                self.canvasStat.create_rectangle(90,25,150,35,fill="blue",outline="white")
                self.canvasStat.create_rectangle(90,25,90+(pourcentShields*60),35,fill="white")
                self.uniteDefense = self.canvasStat.create_text(180,30, text=self.parent.getTabUnites()[self.selectionne].shields, fill="white")
                self.canvasStat.create_text(50,50, text="Attack :",fill="white")
                self.canvasStat.create_text(90,50, text=self.parent.getTabUnites()[self.selectionne].attaque, fill="white")
                self.canvasStat.create_text(50,60, text="Vitesse :",fill="white")
                self.canvasStat.create_text(90,60, text=self.parent.getTabUnites()[self.selectionne].vitesse, fill="white")
                self.canvasStat.create_text(50,70, text="Type :", fill="white")
                self.canvasStat.create_text(110,70, text=self.parent.getTabUnites()[self.selectionne].type, fill="white")
                if self.parent.checkProprietaire(self.selectionne) == 1:
                    self.cadreBoutton=CadreActions(self.canvasStat)
                    
                    if self.parent.getTabUnites()[self.selectionne].type == 'shieldDisruptor':
                        self.boutonShieldDisrupt = PhotoImage(file = 'img/shieldDisruptAction.gif')
                        self.cadreBoutton.setIcone(0, self.boutonShieldDisrupt, "Shield disrupt")
                        self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.boutonShieldDisruptActive)
                    elif self.parent.getTabUnites()[self.selectionne].type == 'reparateur':
                        self.boutonReparer = PhotoImage(file = 'img/reparer.gif')
                        self.cadreBoutton.setIcone(0, self.boutonReparer, "Reparer")
                        self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.boutonReparerActive)
                    elif self.parent.getTabUnites()[self.selectionne].type == 'guide':
                        self.boutonGuide = PhotoImage(file = 'img/guideAction.gif')
                        self.cadreBoutton.setIcone(0, self.boutonGuide, "Activer le guide")
                        self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.boutonGuideActive)
                    else:
                        self.bouttonAttaque = PhotoImage(file = 'img/iconeAttaquegif.gif')
                        self.cadreBoutton.setIcone(0,self.bouttonAttaque, "Attaquer")
                        self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.boutonAttaqueActive)
                    self.bouttonAvance = PhotoImage(file = 'img/iconeAvancegif.gif')
                    self.cadreBoutton.setIcone(1,self.bouttonAvance, "Avancer")
                    self.cadreBoutton.bouton0_1.bind("<ButtonPress-1>", self.boutonAvanceActive)
                    self.bouttonStop = PhotoImage(file = 'img/iconeStop.gif')
                    self.cadreBoutton.setIcone(2,self.bouttonStop, "Arreter")
                    self.cadreBoutton.bouton0_2.bind("<ButtonPress-1>", self.boutonStopActive)
                if self.parent.getTabUnites()[self.selectionne].type == 'scout':
                    self.imageUnite=PhotoImage(file='img/scout.gif')
                if self.parent.getTabUnites()[self.selectionne].type == 'rapide':
                    self.imageUnite=PhotoImage(file='img/vattaque.gif')
                if self.parent.getTabUnites()[self.selectionne].type == 'lent':
                    self.imageUnite=PhotoImage(file='img/vdefense.gif')
                if self.parent.getTabUnites()[self.selectionne].type == 'shieldDisruptor':
                    self.imageUnite=PhotoImage(file='img/shieldDisruptorIcone.gif')
                if self.parent.getTabUnites()[self.selectionne].type == 'reparateur':
                    self.imageUnite=PhotoImage(file='img/reparateur.gif')
                if self.parent.getTabUnites()[self.selectionne].type == 'guide':
                    self.imageUnite=PhotoImage(file='img/guide.gif')
                self.imageUnite=self.imageUnite.zoom(3, 3)
                self.canvasStat.create_rectangle(310,30,450,170,fill='white')
                self.canvasStat.create_image(380,100,image=self.imageUnite)
            self.canvasStat.grid(row=0, column=2)
            self.listSelectionner = False
        
        etoile = self.clicDansEtoile(event)
        if etoile <> -1:
            self.etoileSelectionnee = etoile
                
        if self.etoileSelectionnee <> "":
            self.selectionne=""
            self.canvasStat.destroy()
            self.canvasStat=Canvas(self.frameStat, height=200, width=500, bg="red")
            self.canvasStat.create_text(50,10, text="Nom :",fill="white")
            self.canvasStat.create_text(120,10, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].nom, fill="white")
            self.canvasStat.create_text(50,30, text="Population Max :",fill="white")
            self.canvasStat.create_text(110,30, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].populationMax, fill="white")
            self.canvasStat.create_text(170,30, text="Population :", fill="white")
            self.etoilePopulation = self.canvasStat.create_text(230,30, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].population, fill="white")
            self.canvasStat.create_text(50,50, text="minerai Max :",fill="white")
            self.canvasStat.create_text(110,50, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].mineraiMax, fill="white")
            self.canvasStat.create_text(170,50, text="Minerai :",fill="white")
            self.etoileMinerai = self.canvasStat.create_text(230,50, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].minerai, fill="white")
            self.canvasStat.create_text(50,70, text="gaz Max :",fill="white")
            self.canvasStat.create_text(110,70, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].gazMax, fill="white")
            self.canvasStat.create_text(170,70, text="gaz:",fill="white")
            self.etoileGaz = self.canvasStat.create_text(230,70, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].gaz, fill="white") 
            if self.parent.checkProprietaireEtoile(self.etoileSelectionnee):
                self.cadreBoutton=CadreActions(self.canvasStat)
                self.construireEchange = PhotoImage(file = "img/echange.gif")
                self.cadreBoutton.setIcone(0, self.construireEchange, "Contruire: Centre d'echange")
                self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.constructionEtoile)
                self.construireExtracteur = PhotoImage(file = "img/extracteurSpatial.gif")
                self.cadreBoutton.setIcone(1, self.construireExtracteur,"Contruire: Extracteur")
                self.cadreBoutton.bouton0_1.bind("<ButtonPress-1>", self.constructionEtoile)
                self.construireMilitaire = PhotoImage(file = "img/ militaire.gif")
                self.cadreBoutton.setIcone(2, self.construireMilitaire,"Contruire: Centre militaire")
                self.cadreBoutton.bouton0_2.bind("<ButtonPress-1>", self.constructionEtoile)
                self.construireScience = PhotoImage(file = "img/science.gif")
                self.cadreBoutton.setIcone(3, self.construireScience,"Contruire: Centre de sciences")
                self.cadreBoutton.bouton0_3.bind("<ButtonPress-1>", self.constructionEtoile)
                self.construireAttaque = PhotoImage(file = "img/attaque.gif")
                self.cadreBoutton.setIcone(4, self.construireAttaque,"Contruire: Usine d'attaque")
                self.cadreBoutton.bouton1_0.bind("<ButtonPress-1>", self.constructionEtoile)
                self.construireDefense = PhotoImage(file = "img/defense.gif")
                self.cadreBoutton.setIcone(5, self.construireDefense,"Contruire: Usine de defense")
                self.cadreBoutton.bouton1_1.bind("<ButtonPress-1>", self.constructionEtoile)     
            self.menuStructure.place(x=100,y=200)
            self.menuPlanete.place(x=100,y=250)   
            self.canvasStat.grid(row=0, column=2)
            self.listEtoileSelectionner = False
             
    def deplacer(self, event):
        offsetX = random.randint(-10,10)
        offsetY = random.randint(-10,10)
        offsetZ = random.randint(-10,10)
        destination = self.clicDansUnite(event)
        if destination <> -1:
            if self.selectionne <> "":
                if self.parent.checkProprietaire(self.selectionne) == 1:
                    unite = self.parent.getTabUnites()[destination]
                    self.parent.cancelAttaque(self.selectionne)
                    self.parent.initMouvement(self.selectionne, unite.x+offsetX, unite.y+offsetY, unite.z+offsetZ)
        else:
            destination = self.clicDansEtoile(event)
            if destination <> -1:
                if self.selectionne <> "":
                    if self.parent.checkProprietaire(self.selectionne) == 1:
                        etoile = self.parent.getTabEtoiles()[destination]
                        self.parent.cancelAttaque(self.selectionne)
                        self.parent.initMouvement(self.selectionne, etoile.x+offsetX, etoile.y+offsetY, etoile.z+offsetZ)
                
        self.bouttonAvancePresse = False
        self.cadreBoutton.bouton0_1.delete(self.bouttonAvance)
        self.bouttonAvance = PhotoImage(file='img/iconeAvancegif.gif')
        self.cadreBoutton.setIcone(1,self.bouttonAvance, "Avancer")
        self.cadreBoutton.bouton0_1.config(relief=RAISED)
        
        
    def afficher(self):
        compteur = 0
        tab = self.parent.getTabUnites()
        self.listeUnitesEcran = threedlib.toEcranCercles(self.camera, self.parent.getTabUnites(), "couleur")
        for cercle in self.listeUnitesEcran:

            couleur = self.couleurs[tab[compteur].proprietaire]
            if(tab[compteur].hp==0):
                tab[compteur].statut = 'mort'
                if(compteur == self.selectionne):
                    self.selectionne = ""
                    self.listUnite()
            if (cercle.z>=0):
                try:
                    if(tab[compteur].statut == 'vivant'):
                           self.canvasJeu.create_oval(cercle.x, cercle.y, cercle.x+((600-cercle.z)/50)+2, cercle.y+((600-cercle.z)/50)+2, fill = couleur)
                except:
                    pass
                if compteur == self.selectionne:
                    self.canvasJeu.create_oval(cercle.x-(cercle.x-(cercle.x-((600-cercle.z)/53)+2)), cercle.y-(cercle.y-(cercle.y-((600-cercle.z)/53)+2)), cercle.x+((600-cercle.z)/30)+2,cercle.y+((600-cercle.z)/30)+2, fill="", outline="white")
                    self.canvasJeu.create_oval(cercle.x, cercle.y, cercle.x+((600-cercle.z)/50)+2,cercle.y+((600-cercle.z)/50)+2, fill=couleur)

                compteur += 1


#        for i in self.parent.getTabUnites():
#            try:
#                if self.selectionne==compteur and i.statut=="vivant":
#                    self.canvasJeu.create_oval(i.x+(600), i.y+(400), i.x+(600)+20, i.y+(400)+20, fill="yellow") 
#                    compteur += 1
#                elif i.statut=="vivant":
#                    self.canvasJeu.create_oval(i.x+600, i.y+400,i.x+600+20, i.y+400+20, fill="red")
#                    compteur += 1
#            except:
#                pass
                
    def afficherEtoiles(self):
        self.listeEtoilesEcran = threedlib.toEcranCercles(self.camera, self.parent.getTabEtoiles(), "white")
        for cercle in self.listeEtoilesEcran:
            if (cercle.z>=0):
                try:
                    self.canvasJeu.create_oval(cercle.x, cercle.y, cercle.x+((600-cercle.z)/50)+2, cercle.y+((600-cercle.z)/50)+2, fill = "white")
                except:
                    pass
        if self.etoileSelectionnee <> "":
            i = self.listeEtoilesEcran[self.etoileSelectionnee]
            self.canvasJeu.create_oval(i.x-(i.x-(i.x-((600-i.z)/53)+2)), i.y-(i.y-(i.y-((600-i.z)/53)+2)), i.x+((600-i.z)/30)+2,i.y+((600-i.z)/30)+2, fill="", outline="white")
            self.canvasJeu.create_oval(i.x, i.y, i.x+((600-i.z)/50)+2, i.y+((600- i.z)/50)+2, fill="grey")
            
            
    def effacer(self):
        self.canvasJeu.delete(ALL)
#        for i in self.parent.getTabUnites():
#            try:
#                self.canvasJeu.create_oval(i.x+(600), i.y+(400), i.x+(600)+20, i.y+(400)+20, fill="black")
#            except:
#                pass
    def statJoueur(self):
        j=15;
        self.canvasJoueur.destroy()
        self.canvasJoueur = Canvas(self.frameJeu, height=(self.height/3)*2, width=(self.width/3)/2, bg ='black',bd=5, relief=RIDGE)
        self.canvasJoueur.grid(row=0 , column=0)
        self.canvasJoueur.create_text(100,20, text="Numero de joueur : "+self.parent.modele.joueur.nom, fill='white')
        self.canvasJoueur.create_text(100,40, text="Argent : "+ str(self.parent.modele.joueur.gold), fill='white')            
        self.canvasJoueur.create_text(100,55, text='+'+str(self.parent.modele.joueur.augmentationargent),fill='white')
        self.canvasJoueur.create_text(100,100, text="Points Militaire : "+str(self.parent.modele.joueur.pMilitaire),fill='white')
        self.canvasJoueur.create_text(100,115, text="Points Science : "+str(self.parent.modele.joueur.pScience),fill='white')
        self.canvasJoueur.create_text(100,130, text="Points Echange : "+str(self.parent.modele.joueur.pEchange),fill='white')
        if self.etoileSelectionnee<>"":
            if self.planeteSelectionnee<>"":
                self.canvasJoueur.create_text(80,175,text="Liste de Batiments : ", fill="white")
                for i in self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes[self.planeteSelectionnee].batiments:
                    self.canvasJoueur.create_text(100,190+j,text=i.type+": "+i.etatAffichage,fill="white")
                    j=j+15
                    
    def technologie(self):
        self.parent.modele.tech.init()
        
    def stat(self):
        pourcentHealth=float(self.parent.getTabUnites()[self.selectionne].hp)/float(CONSTANTESUNITES.unites[self.parent.getTabUnites()[self.selectionne].type]['hp'])
        pourcentShields=float(self.parent.getTabUnites()[self.selectionne].shields)/float(CONSTANTESUNITES.unites[self.parent.getTabUnites()[self.selectionne].type]['shields'])
        self.canvasStat.create_rectangle(90,5,150,15,fill="blue",outline="white")
        self.canvasStat.create_rectangle(90,5,90+(60*pourcentHealth),15,fill="white")
        self.canvasStat.itemconfig(self.uniteHP, text=self.parent.getTabUnites()[self.selectionne].hp)
        self.canvasStat.create_rectangle(90,25,150,35,fill="blue",outline="white")
        self.canvasStat.create_rectangle(90,25,90+(pourcentShields*60),35,fill="white")
        self.canvasStat.itemconfig(self.uniteDefense, text=self.parent.getTabUnites()[self.selectionne].shields )
    
    def statTampon(self):
        self.canvasStat.destroy()
        self.canvasStat=Canvas(self.frameStat, height=200, width=500, bg="blue")
        self.canvasStat.grid(row=0,column=2)
        
    def statEtoile(self):
        self.canvasStat.itemconfig(self.etoilePopulation, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].population)
        self.canvasStat.itemconfig(self.etoileMinerai, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].minerai)
        self.canvasStat.itemconfig(self.etoileGaz, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].gaz)
        
        
    def constructionEtoile(self,event):
        if event.widget == self.cadreBoutton.bouton0_0:
            self.message=self.parent.construireStructure('centreEchange',self.etoileSelectionnee)
        if event.widget == self.cadreBoutton.bouton0_1:
            self.message=self.parent.construireStructure('extracteurSpatial',self.etoileSelectionnee)
        if event.widget == self.cadreBoutton.bouton0_2:
            self.message=self.parent.construireStructure('centreMilitaire',self.etoileSelectionnee)
        if event.widget == self.cadreBoutton.bouton0_3:
            self.message=self.parent.construireStructure('centreSciences',self.etoileSelectionnee)
        if event.widget == self.cadreBoutton.bouton1_0:
            self.message=self.parent.construireStructure('usineAttaque',self.etoileSelectionnee)
        if event.widget == self.cadreBoutton.bouton1_1:
            self.message=self.parent.construireStructure('usineDefense',self.etoileSelectionnee)
        self.messageAction()        
        
    def miniMap(self):
        self.canvasMiniMap = Canvas(self.canvasOption, height=190, width=190, bg="black")
        self.canvasMiniMap.create_rectangle(25, 15, 175, 40, fill="white")
        self.canvasMiniMap.create_text(100, 28, font = ("Arial", 16), text = "Mini-Map")
        self.canvasMiniMap.place(x=5,y=5)
        
    def statPlanete(self):
        self.canvasStat.itemconfig(self.planeteMinerai, text=self.parent.getTabEtoiles()[int(self.etoileSelectionnee)].tabPlanetes[self.planeteSelectionnee].minerai)
        self.canvasStat.itemconfig(self.planetePopulation, text=self.parent.getTabEtoiles()[int(self.etoileSelectionnee)].tabPlanetes[self.planeteSelectionnee].population)
        self.canvasStat.itemconfig(self.planeteGaz, text=self.parent.getTabEtoiles()[int(self.etoileSelectionnee)].tabPlanetes[self.planeteSelectionnee].gaz)

    def constructionPlanete(self,event):
        if event.widget == self.cadreBoutton.bouton0_0:
            typeBatiment="extracteurGaz"
        elif event.widget == self.cadreBoutton.bouton0_1:
            typeBatiment="extracteurMinerai"
        elif event.widget == self.cadreBoutton.bouton0_2:
            typeBatiment="agricultureFerme"
        elif event.widget == self.cadreBoutton.bouton0_3:
            typeBatiment="hopital"
        elif event.widget == self.cadreBoutton.bouton1_0:
            typeBatiment="recycleur"
        elif event.widget == self.cadreBoutton.bouton1_1:
            typeBatiment="tour"
        elif event.widget == self.cadreBoutton.bouton1_2:
            typeBatiment="bouclier"

        planeteSelectionnee=self.listeSelect.get(ACTIVE)
        self.message=self.parent.creerBatiment(planeteSelectionnee, self.etoileSelectionnee, typeBatiment)
        self.messageAction()   
            
    def statStructure(self):
        self.canvasStat.itemconfig(self.structureHP, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures[self.structureSelectionnee].vie)
        self.canvasStat.itemconfig(self.structureDefense, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures[self.structureSelectionnee].bouclier)

    
    def messageAction(self):
        message=Toplevel()
        Label(message, text=self.message).pack()
        Button(message, text="Ok",command=message.destroy).pack()
        message.geometry('+500+500')
        message.focus_set()
        message.grab_set()
        
    def actionMilitaire(self,event):
        if event.widget == self.cadreBoutton.bouton0_0: 
            self.message=self.parent.augmentePoint(self.typeStruct)
        self.messageAction()
        
    def actionScience(self,event):
        if event.widget == self.cadreBoutton.bouton0_0: 
            self.message=self.parent.augmentePoint(self.typeStruct)
        self.messageAction()
            
    def actionEchange(self,event):
        if event.widget == self.cadreBoutton.bouton0_0: 
            self.message=self.parent.augmentePoint(self.typeStruct)
        self.messageAction()
        
    def actionAttaque(self,event):
        if event.widget == self.cadreBoutton.bouton0_0: 
            self.message=self.parent.creerUnite('rapide', self.etoileSelectionnee)
        elif event.widget == self.cadreBoutton.bouton0_1:
            self.message=self.parent.creerUnite('lent', self.etoileSelectionnee)
        elif event.widget == self.cadreBoutton.bouton0_2:
            self.message=self.parent.creerUnite('motherShip', self.etoileSelectionnee)
        self.messageAction()
        
    def actionDefense(self,event):
        if event.widget == self.cadreBoutton.bouton0_0: 
            self.message=self.parent.creerUnite('scout', self.etoileSelectionnee)
        elif event.widget == self.cadreBoutton.bouton0_1:
            self.message=self.parent.creerUnite('shieldDisruptor', self.etoileSelectionnee)
        elif event.widget == self.cadreBoutton.bouton0_2:
            self.message=self.parent.creerUnite('reparateur', self.etoileSelectionnee)
        self.messageAction()
        
    def actionStationSpatiale(self,event):
        if event.widget == self.cadreBoutton.bouton0_0: 
            self.message=self.parent.creerUnite('guide', self.etoileSelectionnee)
            print "etoile: "+str(self.etoileSelectionnee)
        #else:
        #    if event.widget == self.cadreBoutton.bouton0_1:
        #        self.message = self.parent.augmenterPopulation(self.etoileSelectionnee) 
        self.messageAction()
            
        

    def listUnite(self):
        #if self.uniteBool == False:
            self.listeSelect.destroy()
            self.listeSelect=Listbox(self.canvasOption, bg="blue", bd=5)
            tab = self.parent.getTabUnites()
            for self.unites  in  self.parent.modele.joueur.unites:
                if (tab[self.unites].statut == 'vivant'):
                    self.listeSelect.insert(END,self.unites)#self.parent.modele.univers.tabUnites[self.unites].type
            self.listeSelect.place(x=25,y=300)
            self.listeSelect.bind("<ButtonPress-1>", self.setSelectionner)
        #    self.uniteBool = True
        #else:
        #    self.listeSelect.destroy()
        #    self.uniteBool=False
        
        
    def listEtoile(self):
        #if self.etoileBool == False:
            self.listeSelect.destroy()
            self.listeSelect=Listbox(self.canvasOption, bg="red",bd=5)
            for self.etoile in self.parent.modele.joueur.etoiles:
                self.listeSelect.insert(END, self.etoile)
            self.listeSelect.place(x=25,y=300)
            self.listeSelect.bind("<ButtonPress-1>", self.setEtoileSelectionnee)
        #    self.etoileBool=True
        #else:
        #     self.listeSelect.destroy()
        #     self.etoileBool=False
        
    def listPlanete(self):
        self.listeSelect.destroy()
        self.listeSelect=Listbox(self.canvasOption, bg="olive drab",bd=5, selectmode=SINGLE)
        for i in range(len(self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes)):
            self.listeSelect.insert(END, i)
            print i
        self.listeSelect.bind("<ButtonPress-1>", self.setStatPlanete)
        self.listeSelect.place(x=25,y=300)
        
    def listStructure(self):
        self.listeSelect.destroy()
        self.listeSelect=Listbox(self.canvasOption, bg="yellow",bd=5)
        for i in range(len(self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures)):
            self.listeSelect.insert(END, i)
        self.listeSelect.bind("<ButtonPress-1>", self.setStatStructure)
        self.listeSelect.place(x=25,y=300)
        
    def setStatPlanete(self,event):
        self.selectionne=""
        self.structureSelectionnee=""
        self.canvasStat.destroy()
        self.canvasStat=Canvas(self.frameStat, height=200, width=500, bg="olive drab")
        self.planeteSelectionnee=(int)(self.listeSelect.get(ACTIVE))
        print self.planeteSelectionnee
        if self.etoileSelectionnee<>"":
            self.canvasStat.create_text(50,10, text="Systeme :",fill="white")
            self.canvasStat.create_text(120,10, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes[self.planeteSelectionnee].etoile.nom, fill="white")
            self.canvasStat.create_text(50,30, text="Minerai :",fill="white")
            self.planeteMinerai = self.canvasStat.create_text(110,30, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes[self.planeteSelectionnee].minerai, fill="white")
            self.canvasStat.create_text(170,30, text="Population :", fill="white")
            self.planetePopulation = self.canvasStat.create_text(230,30, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes[self.planeteSelectionnee].population, fill="white")
            self.canvasStat.create_text(50,50, text="Gaz :",fill="white")
            self.planeteGaz = self.canvasStat.create_text(110,50, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes[self.planeteSelectionnee].gaz, fill="white")
            self.canvasStat.create_text(170,50, text="Type :",fill="white")
            self.canvasStat.create_text(230,50, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabPlanetes[self.planeteSelectionnee].type, fill="white")
            self.cadreBoutton=CadreActions(self.canvasStat)

            self.boutonExtracteurGaz = PhotoImage(file = "img/extracteurGaz.gif")
            self.cadreBoutton.setIcone(0, self.boutonExtracteurGaz,"Extracteur gaz")
            self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.constructionPlanete)
            
            self.boutonExtracteurMinerai = PhotoImage(file = "img/extracteurMinerai.gif")
            self.cadreBoutton.setIcone(1, self.boutonExtracteurMinerai, "Extracteur minerai")
            self.cadreBoutton.bouton0_1.bind("<ButtonPress-1>", self.constructionPlanete)

            
            self.boutonFerme = PhotoImage(file = "img/ferme.gif")
            self.cadreBoutton.setIcone(2, self.boutonFerme, "Ferme")
            self.cadreBoutton.bouton0_2.bind("<ButtonPress-1>", self.constructionPlanete)
            
            self.boutonHopital = PhotoImage(file = "img/hopital.gif")
            self.cadreBoutton.setIcone(3, self.boutonHopital, "Hopital")
            self.cadreBoutton.bouton0_3.bind("<ButtonPress-1>", self.constructionPlanete)
            
            self.boutonRecycleur = PhotoImage(file = "img/recycleur.gif")
            self.cadreBoutton.setIcone(4, self.boutonRecycleur, "Recycleur")
            self.cadreBoutton.bouton1_0.bind("<ButtonPress-1>", self.constructionPlanete)
            
            self.boutonTour = PhotoImage(file = "img/tour.gif")
            self.cadreBoutton.setIcone(5, self.boutonTour, "Tour")
            self.cadreBoutton.bouton1_1.bind("<ButtonPress-1>", self.constructionPlanete)
            
            self.boutonBouclier = PhotoImage(file = "img/bouclier.gif")
            self.cadreBoutton.setIcone(6, self.boutonBouclier, "Bouclier")
            self.cadreBoutton.bouton1_2.bind("<ButtonPress-1>", self.constructionPlanete)

        if self.parent.getTabEtoiles()[int(self.etoileSelectionnee)].tabPlanetes[self.planeteSelectionnee].type == "Gazeuse":
            self.imagePlanete=PhotoImage(file='img/gazeuze.gif')
        if self.parent.getTabEtoiles()[int(self.etoileSelectionnee)].tabPlanetes[self.planeteSelectionnee].type == "Habitable":
            self.imagePlanete=PhotoImage(file='img/habitable.gif')
        if self.parent.getTabEtoiles()[int(self.etoileSelectionnee)].tabPlanetes[self.planeteSelectionnee].type == "Morte":
            self.imagePlanete=PhotoImage(file='img/morte.gif')
        self.canvasStat.create_rectangle(310,30,450,170,fill='white')
        self.canvasStat.create_image(380,100,image=self.imagePlanete)
        self.canvasStat.grid(row=0, column=2)
        
    def setStatStructure(self,event):
        self.selectionne=""
        self.canvasStat.destroy()
        self.canvasStat=Canvas(self.frameStat, height=200, width=500, bg="yellow")
        self.structureSelectionnee=self.listeSelect.get(ACTIVE)
        if self.etoileSelectionnee<>"":
            self.canvasStat.create_text(50,10, text="Systeme :",fill="black")
            self.canvasStat.create_text(120,10, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures[self.structureSelectionnee].parent.nom, fill="black")
            self.canvasStat.create_text(50,30, text="Vie :",fill="black")
            self.structureHP = self.canvasStat.create_text(110,30, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures[self.structureSelectionnee].vie, fill="black")
            self.canvasStat.create_text(170,30, text="Bouclier :", fill="black")
            self.structureDefense = self.canvasStat.create_text(230,30, text=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures[self.structureSelectionnee].bouclier, fill="black")
            self.typeStruct=self.parent.getTabEtoiles()[self.etoileSelectionnee].tabStructures[self.structureSelectionnee].type
            self.canvasStat.create_text(70,50, text=self.typeStruct, fill="black")
            self.cadreBoutton=CadreActions(self.canvasStat)
            if self.typeStruct == "stationSpatiale":
                self.ImageStructure=PhotoImage(file='img/stationSpatiale.gif')
                self.bouttonUnite = PhotoImage(file = 'img/guide.gif')
                self.cadreBoutton.setIcone(0,self.bouttonUnite, "Construire un guide")
                self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.actionStationSpatiale)
                #self.bouttonPopulation = PhotoImage(file= 'img/population.gif')
                #self.cadreBoutton.setIcone(1,self.bouttonPopulation, "Population")
                #self.cadreBoutton.bouton0_1.bind("<ButtonPress-1>",self.actionStationSpatiale)              
            else:
                if self.typeStruct == "centreEchange" :
                    self.ImageStructure=PhotoImage(file='img/echange.gif')
                    self.bouttonAugmente = PhotoImage(file = 'img/augmente.gif')
                    self.cadreBoutton.setIcone(0, self.bouttonAugmente, "Augmenter")
                    self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.actionEchange)
                else:
                    if self.typeStruct == "extracteurSpatial":
                        self.ImageStructure=PhotoImage(file='img/extracteurSpatial.gif')
                    else:
                        if self.typeStruct == "centreMilitaire":
                            self.ImageStructure=PhotoImage(file='img/ militaire.gif')
                            self.bouttonAugmente = PhotoImage(file = 'img/augmente.gif')
                            self.cadreBoutton.setIcone(0, self.bouttonAugmente, "Augmente")
                            self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.actionMilitaire)
                        else:
                            if self.typeStruct == "centreSciences":
                                self.ImageStructure=PhotoImage(file='img/science.gif')
                                self.bouttonAugmente = PhotoImage(file = 'img/augmente.gif')
                                self.cadreBoutton.setIcone(0, self.bouttonAugmente, "Augmente")
                                self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.actionScience)
                            else:
                                if self.typeStruct == "usineAttaque":
                                    self.ImageStructure=PhotoImage(file='img/attaque.gif')
                                    self.bouttonUnite = PhotoImage(file = 'img/vattaque.gif')
                                    self.cadreBoutton.setIcone(0,self.bouttonUnite, "Rapide")
                                    self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.actionAttaque)
                                    self.bouttonUnite2 = PhotoImage(file = 'img/vattaque.gif')
                                    self.cadreBoutton.setIcone(1,self.bouttonUnite2, "Lent")
                                    self.cadreBoutton.bouton0_1.bind("<ButtonPress-1>", self.actionAttaque)
                                    self.bouttonUnite3 = PhotoImage(file = 'img/vattaque.gif')
                                    self.cadreBoutton.setIcone(2,self.bouttonUnite3, "Mother Ship")
                                    self.cadreBoutton.bouton0_2.bind("<ButtonPress-1>", self.actionAttaque)
                                else:
                                    if self.typeStruct == "usineDefense":
                                        self.ImageStructure=PhotoImage(file='img/defense.gif')
                                        self.bouttonUnite = PhotoImage(file = 'img/vdefense.gif')
                                        self.cadreBoutton.setIcone(0,self.bouttonUnite, "scout")
                                        self.cadreBoutton.bouton0_0.bind("<ButtonPress-1>", self.actionDefense)
                                        self.bouttonUnite2 = PhotoImage(file = 'img/shieldDisruptorIcone.gif')
                                        self.cadreBoutton.setIcone(1, self.bouttonUnite2, "shield disruptor")
                                        self.cadreBoutton.bouton0_1.bind("<ButtonPress-1>", self.actionDefense)
                                        self.bouttonUnite3 = PhotoImage(file = 'img/reparateur.gif')
                                        self.cadreBoutton.setIcone(2, self.bouttonUnite3, "reparateur")
                                        self.cadreBoutton.bouton0_2.bind("<ButtonPress-1>", self.actionDefense)
        self.ImageStructure=self.ImageStructure.zoom(3, 3)
        self.canvasStat.create_rectangle(310,30,450,170,fill='black')
        self.canvasStat.create_image(380,100,image=self.ImageStructure)
        self.canvasStat.grid(row=0, column=2)
        
    def setEtoileSelectionnee(self,event):
        self.listEtoileSelectionner = True
        self.etoileSelectionnee=int(self.listeSelect.get(ACTIVE))
        self.selection(event)

    def setSelectionner(self,event):
        self.listSelectionner = True
        self.selectionne=int(self.listeSelect.get(ACTIVE))
        self.selection(event)
        print self.selectionne
      
       
    def attaquer(self,event):
        if self.selectionne <> "":
            compteur=0
#            for i in self.listeUnitesEcran:
#                if event.x >= i.x+600 and event.x <= i.x+600+((600-i.z)/50)+2:
#                    if event.y >= i.y+400 and event.y <= i.y+400+((600-i.z)/50)+2:
#                        if i.statut == "vivant":
#                            self.cible = compteur
#                compteur +=1
            self.cible = self.clicDansUnite(event)
            if self.cible <> -1:
                if self.parent.checkProprietaire(self.selectionne) == 1:
                    if self.parent.checkProprietaire(self.cible) == 0:
                        attaquant=self.selectionne
                        defenseur=self.cible
                        self.parent.initAttaque(attaquant,defenseur)
        self.bouttonAttaquePresse = False
        self.cadreBoutton.bouton0_0.delete(self.bouttonAttaque)
        self.bouttonAttaque = PhotoImage(file='img/iconeAttaquegif.gif')
        self.cadreBoutton.setIcone(0,self.bouttonAttaque, "Attaquer")
        self.cadreBoutton.bouton0_0.config(relief=RAISED)
        
    def construireStationSpatiale(self,event):
        self.cible=self.clicDansEtoile(event)
        if self.cible <> -1:
            if self.parent.getTabEtoiles()[self.cible].proprietaire == "":
                self.parent.approprierEtoile(self.selectionne, self.cible)

        self.bouttonGuidePresse = False
        
    def shieldDisrupt(self, event):
        if self.selectionne <> "":
            compteur=0
            for i in self.listeUnitesEcran:
                if event.x >= i.x+600 and event.x <= i.x+600+((600-i.z)/50)+2:
                    if event.y >= i.y+400 and event.y <= i.y+400+((600-i.z)/50)+2:
                        if i.statut == "vivant":
                            self.cible = compteur
                compteur +=1
            if self.parent.checkProprietaire(self.selectionne) == 1:
                attaquant=self.selectionne
                defenseur=self.cible
                self.parent.shieldDisrupt(attaquant,defenseur)
            self.afficher()
#            for i in self.listeUnitesEcran:
#                if event.x >= i.x+600 and event.x <= i.x+600+((600-i.z)/50)+2:
#                    if event.y >= i.y+400 and event.y <= i.y+400+((600-i.z)/50)+2:
#                        if i.statut == "vivant":
#                            self.cible = compteur
#                compteur +=1
            self.cible = self.clicDansUnite(event)
            if self.cible <> -1:
                if self.parent.checkProprietaire(self.selectionne) == 1:
                    if self.parent.checkProprietaire(self.cible) == 0:
                        attaquant=self.selectionne
                        defenseur=self.cible
                        self.parent.initAttaque(attaquant,defenseur)
        self.bouttonShieldDisruptPresse = False
        
    def initReparer(self, event):
        if self.selectionne <> "":
            if self.parent.checkProprietaire(self.selectionne) == 1:
                reparateur=self.selectionne
                aReparer=self.cible
                self.parent.initReparer(reparateur,aReparer)
            self.afficher()
#            for i in self.listeUnitesEcran:
#                if event.x >= i.x+600 and event.x <= i.x+600+((600-i.z)/50)+2:
#                    if event.y >= i.y+400 and event.y <= i.y+400+((600-i.z)/50)+2:
#                        if i.statut == "vivant":
#                            self.cible = compteur
#                compteur +=1
#            self.cible = self.clicDansUnite(event)
#            if self.cible <> -1:
#                if self.parent.checkProprietaire(self.selectionne) == 1:
#                    if self.parent.checkProprietaire(self.cible) == 0:
#                        attaquant=self.selectionne
#                        defenseur=self.cible
#                        self.parent.initAttaque(attaquant,defenseur)
        self.bouttonReparerPresse = False
    
    def deplacerCamera(self,event):
        if event.x > self.posSourisX+10:
            self.camera.bougerX(-10)
        elif event.x > self.posSourisX+5:
            self.camera.bougerX(-5)
        elif event.x > self.posSourisX+3:
            self.camera.bougerX(-3)
        elif event.x < self.posSourisX-10:
            self.camera.bougerX(10)
        elif event.x < self.posSourisX-5:
            self.camera.bougerX(5)
        elif event.x < self.posSourisX-3:
            self.camera.bougerX(3)
           
        if event.y > self.posSourisY+10:
            self.camera.bougerY(10)
        elif event.y > self.posSourisY+5:
            self.camera.bougerY(5)
        elif event.y > self.posSourisY+3:
            self.camera.bougerY(3)
        elif event.y < self.posSourisY-10:
            self.camera.bougerY(-10)
        elif event.y < self.posSourisY-5:
            self.camera.bougerY(-5)
        elif event.y < self.posSourisY-3:
            self.camera.bougerY(-3)
        self.posSourisX = event.x
        self.posSourisY = event.y
    
    def rotationCamera(self, event):
        if event.x > self.posSourisX+2:
            self.camera.yawer(-0.01)
        elif event.x < self.posSourisX-2:
            self.camera.yawer(0.01)
           
        if event.y > self.posSourisY+2:
            self.camera.pitcher(-0.01)
        elif event.y < self.posSourisY-2:
            self.camera.pitcher(0.01)
        self.posSourisX = event.x
        self.posSourisY = event.y
        
    def zoom(self, event):
        valeur = self.sliderZoom.get()
        if self.valeurZoom > valeur:
            self.camera.bougerZ(20)
        else:
            self.camera.bougerZ(-20)
        self.valeurZoom = valeur

  
    def boutonAttaqueActive(self, event):
        self.bouttonAttaquePresse = True
        self.cadreBoutton.bouton0_0.delete(self.bouttonAttaque)
        self.bouttonAttaque = PhotoImage(file='img/iconeAttaquegifEnfonce.gif')
        self.cadreBoutton.setIcone(0,self.bouttonAttaque, "Attaquer")
        self.cadreBoutton.bouton0_0.config(relief=SUNKEN)
        
    def boutonShieldDisruptActive(self, event):
        self.bouttonShieldDisruptPresse = True
        
    def boutonAvanceActive(self, event):
        self.bouttonAvancePresse = True
        self.cadreBoutton.bouton0_1.delete(self.bouttonAvance)
        self.bouttonAvance = PhotoImage(file='img/iconeAvancegifEnfonce.gif')
        self.cadreBoutton.setIcone(1,self.bouttonAvance, "Avancer")
        self.cadreBoutton.bouton0_1.config(relief=SUNKEN)
        
    def boutonStopActive(self, event):
        z=10 ##En attendant qqchose de 3Dish
        self.parent.cancelAttaque(self.selectionne)
        self.parent.initMouvement(self.selectionne, self.parent.getTabUnites()[self.selectionne].x, self.parent.getTabUnites()[self.selectionne].y, z)
        
    
    def boutonGuideActive(self, event):
        self.bouttonGuidePresse = True
        
        
    def boutonReparerActive(self, event):
        self.bouttonReparerPresse = True
    
    def clicGauche(self, event):
        self.posSourisX=event.x
        self.posSourisY=event.y
        if self.bouttonAttaquePresse:
            self.attaquer(event)
        elif self.bouttonAvancePresse:
            self.deplacer(event)
        elif self.bouttonShieldDisruptPresse:
            self.shieldDisrupt(event)
        elif self.bouttonReparerPresse:
            self.initReparer(event)
        elif self.bouttonGuidePresse:
            self.construireStationSpatiale(event)
        else:
            self.selection(event)
        
            
    def creerChat(self):
        self.canvasChat = Canvas(self.frameStat, height=200, width=250, bg ='black',bd=5, relief=RIDGE)
        self.canvasChat.grid(row=0, column=1)
        self.chat=[]
        self.chat.append(self.canvasChat.create_text(10, 200/7*6, text="", fill='white', anchor=W))
        self.chat.append(self.canvasChat.create_text(10, 200/7*5, text="", fill='white', anchor=W))
        self.chat.append(self.canvasChat.create_text(10, 200/7*4, text="", fill='white', anchor=W))
        self.chat.append(self.canvasChat.create_text(10, 200/7*3, text="", fill='white',anchor=W))
        self.chat.append(self.canvasChat.create_text(10, 200/7*2, text="", fill='white', anchor=W))
        self.chat.append(self.canvasChat.create_text(10, 200/7, text="", fill='white', anchor=W))
        
        #self.entrerChat.bind("<Return>", self.enterChat)
        
    def enterChat(self, event):
        if self.chatOuvert:
            self.parent.nouveauTextChat(self.entrerChat.get())
            self.entrerChat.destroy()
            self.chatOuvert=False
        else:
            self.entrerChat=Entry(self.canvasChat, width=40)
            self.entrerChat.place(x=10, y=183)
            self.entrerChat.focus_set()
            self.chatOuvert=True
        
    def changerTextChat(self, chat, joueur):
        if len(chat) > 30:
            nombreLigne = (len(chat)/40)+1
            if nombreLigne == 2:
                self.canvasChat.itemconfig(self.chat[5], text=self.canvasChat.itemcget(self.chat[3], "text"))
                self.canvasChat.itemconfig(self.chat[4], text=self.canvasChat.itemcget(self.chat[2], "text"))
                self.canvasChat.itemconfig(self.chat[3], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[2], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[1], text=joueur + ": " + chat[0:30])
                self.canvasChat.itemconfig(self.chat[0], text=chat[30:len(chat)])
            elif nombreLigne == 3:
                self.canvasChat.itemconfig(self.chat[5], text=self.canvasChat.itemcget(self.chat[2], "text"))
                self.canvasChat.itemconfig(self.chat[4], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[3], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[2], text=joueur + ": " + chat[0:30])
                self.canvasChat.itemconfig(self.chat[1], text=chat[30:73])
                self.canvasChat.itemconfig(self.chat[0], text=chat[73:len(chat)])
            elif nombreLigne == 4:
                self.canvasChat.itemconfig(self.chat[5], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[4], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[3], text=joueur + ": " + chat[0:30])
                self.canvasChat.itemconfig(self.chat[2], text=chat[30:73])
                self.canvasChat.itemconfig(self.chat[1], text=chat[73:116])
                self.canvasChat.itemconfig(self.chat[0], text=chat[116:len(chat)])
            elif nombreLigne == 5:
                self.canvasChat.itemconfig(self.chat[5], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[4], text=joueur + ": " + chat[0:30])
                self.canvasChat.itemconfig(self.chat[3], text=chat[30:73])
                self.canvasChat.itemconfig(self.chat[2], text=chat[73:116])
                self.canvasChat.itemconfig(self.chat[1], text=chat[116:159])
                self.canvasChat.itemconfig(self.chat[0], text=chat[159:len(chat)])
            elif nombreLigne == 6:
                self.canvasChat.itemconfig(self.chat[5], text=joueur + ": " + chat[0:30])
                self.canvasChat.itemconfig(self.chat[4], text=chat[30:73])
                self.canvasChat.itemconfig(self.chat[3], text=chat[73:116])
                self.canvasChat.itemconfig(self.chat[2], text=chat[116:159])
                self.canvasChat.itemconfig(self.chat[1], text=chat[159:202])
                self.canvasChat.itemconfig(self.chat[0], text=chat[202:len(chat)])
            else:
                self.canvasChat.itemconfig(self.chat[5], text=joueur + ": " + chat[0:30])
                self.canvasChat.itemconfig(self.chat[4], text=chat[30:73])
                self.canvasChat.itemconfig(self.chat[3], text=chat[73:116])
                self.canvasChat.itemconfig(self.chat[2], text=chat[116:159])
                self.canvasChat.itemconfig(self.chat[1], text=chat[159:202])
                self.canvasChat.itemconfig(self.chat[0], text=chat[202:245])
        else:
            if self.canvasChat.itemcget(self.chat[0], "text") == "":
                self.canvasChat.itemconfig(self.chat[0], text=joueur + ": " + chat)
            elif self.canvasChat.itemcget(self.chat[1], "text") == "":
                self.canvasChat.itemconfig(self.chat[1], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[0], text=joueur + ": " + chat)
            elif self.canvasChat.itemcget(self.chat[2], "text") == "":
                self.canvasChat.itemconfig(self.chat[2], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[1], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[0], text=joueur + ": " + chat)
            elif self.canvasChat.itemcget(self.chat[3], "text") == "":
                self.canvasChat.itemconfig(self.chat[3], text=self.canvasChat.itemcget(self.chat[2], "text"))
                self.canvasChat.itemconfig(self.chat[2], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[1], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[0], text=joueur + ": " + chat)
            elif self.canvasChat.itemcget(self.chat[4], "text") == "":
                self.canvasChat.itemconfig(self.chat[4], text=self.canvasChat.itemcget(self.chat[3], "text"))
                self.canvasChat.itemconfig(self.chat[3], text=self.canvasChat.itemcget(self.chat[2], "text"))
                self.canvasChat.itemconfig(self.chat[2], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[1], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[0], text=joueur + ": " + chat)
            elif self.canvasChat.itemcget(self.chat[5], "text") == "":
                self.canvasChat.itemconfig(self.chat[5], text=self.canvasChat.itemcget(self.chat[4], "text"))
                self.canvasChat.itemconfig(self.chat[4], text=self.canvasChat.itemcget(self.chat[3], "text"))
                self.canvasChat.itemconfig(self.chat[3], text=self.canvasChat.itemcget(self.chat[2], "text"))
                self.canvasChat.itemconfig(self.chat[2], text=self.canvasChat.itemcget(self.chat[1], "text"))
                self.canvasChat.itemconfig(self.chat[1], text=self.canvasChat.itemcget(self.chat[0], "text"))
                self.canvasChat.itemconfig(self.chat[0], text=joueur + ": " + chat)
        